#pragma once

#include "common.h"

////////////////////////////////////////////////////////////////
#define	NO_COPY(T)	\
protected:	\
	T(const T&) {}	\
	T& operator=(const T&)	{}


////////////////////////////////////////////////////////////////
#define	NEW_RELEASE(T)	\
public:	\
	static T* create_new() 	{ return new T; }	\
	void release() 		{ delete this; }	\
	void release_by_owner() 		{ delete this; }	\
protected:


////////////////////////////////////////////////////////////////
#define	COM_STYLE(T)	\
	NEW_RELEASE(T)	\
	NO_COPY(T)	\
protected:


////////////////////////////////////////////////////////////////
#define	COM_STYLE_HEAP(T)	\
	COM_STYLE(T)	\
protected:	\
	T() {}	\
	virtual ~T() {}	\
protected:


////////////////////////////////////////////////////////////////
#define	COM_STYLE_STACK(T)	\
	COM_STYLE(T)	\
public:	\
	T() {}	\
	virtual ~T() {}	\
protected:


////////////////////////////////////////////////////////////////
// typedef
//////////////////////////////////////////////////////////////////////
#define	TYPE_OF(x)			((x**)0)

//////////////////////////////////////////////////////////////////////
template<TYPENAME T>
	struct guid_traits {};
#define GUID_DECLARE(T,i)	template<> struct guid_traits< T > { enum{ id=(i) }; };
#define	GUID_OF(T)			(guid_traits< T >::id)

//////////////////////////////////////////////////////////////////////
#define DEFINE_QI(T,v)		T* QueryInterface(T** ppT) { ASSERT(v); if(ppT) *ppT = v; return v; }

//////////////////////////////////////////////////////////////////////
template<TYPENAME T, TYPENAME X>
inline T* Cast(X* pX) { if(pX) return pX->QueryInterface((T**)0); return NULL; }

template<TYPENAME T, TYPENAME X>
inline bool Cast(T** ppT, X* pX) { CHECKF(ppT); if(pX) return pX->QueryInterface(ppT) != NULL; return *ppT=NULL,false; }

